package com.own.demo.lwf.utils.ownUtils;


import com.own.demo.lwf.utils.workUtils.ValidateUtil;

import java.util.List;
import java.util.Random;

/**
 * @Author liwenfeng
 * @Description dongruan
 * @Date 2023/07/07/14:58
 * @Version 1.0
 */
public class DataConvertUtils {

    /**
     *将16进制数转换为byte数组
     */
    public static byte[] hex2Byte(String hex) {
        String[] parts = hex.split(" ");
        byte[] bytes = new byte[parts.length];
        for (int i = 0; i < parts.length; i++) {
            bytes[i] = (byte) Integer.parseInt(parts[i], 16);
        }
        return bytes;
    }


    /**
     *将byte数组转换为16进制数
     */
    public static final char[] HEX = "0123456789ABCDEF".toCharArray();
    public static String bytesToHex(byte[] bytes, int length) {
        char[] hexChars = new char[bytes.length * 2];
        for (int j = 0; j < Math.min(length, bytes.length); j++) {
            int v = bytes[j] & 0xFF;
            hexChars[j * 2] = HEX[v >>> 4];
            hexChars[j * 2 + 1] = HEX[v & 0x0F];
        }
        return new String(hexChars);
    }



    /**
     *随机产生一组16进制数
     */
    public static String randomHexString(int length) {
        StringBuffer result = new StringBuffer();
        Random random = new Random();
        try {
            for (int i = 0; i < length; i++) {
                String hexString = Integer.toHexString(random.nextInt(255));
                if (hexString.length() == 1) {
                    result.append("0");
                }
                result.append(hexString).append(" ");
            }
            return result.toString();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }


    /**
     * 把字串转化为整数,若转化失败，则返回0
     *
     * @param str 字符串
     * @return
     */
    public static int strToInt(String str) {
        if (str == null) {
            return 0;
        }

        try {
            return Integer.parseInt(str);
        } catch (Exception ex) {
            ex.printStackTrace();
            System.err.println(str + "转换成int类型失败，请检查数据来源");
        }
        return 0;
    }

    /**
     * 把字串转化为长整型数,若转化失败，则返回0
     *
     * @param str
     * @return
     */
    public static long strToLong(String str) {
        if (str == null) {
            return 0;
        }

        try {
            return Long.parseLong(str);
        } catch (Exception ex) {
            ex.printStackTrace();
            System.err.println(str + "转换成long类型失败，请检查数据来源");
        }
        return 0;
    }

    /**
     * 把字串转化为Float型数据,若转化失败，则返回0
     *
     * @param str
     * @return
     */
    public static float strToFloat(String str) {
        if (str == null) {
            return 0;
        }
        try {
            return Float.parseFloat(str);
        } catch (Exception ex) {
            ex.printStackTrace();
            System.err.println(str + "转换成float类型失败，请检查数据来源");
        }
        return 0;
    }

    /**
     * 把字串转化为Double型数据，若转化失败，则返回0
     *
     * @param str
     * @return
     */
    public static double strToDouble(String str) {
        if (str == null) {
            return 0;
        }
        try {
            return Double.parseDouble(str);
        } catch (Exception ex) {
            ex.printStackTrace();
            System.err.println(str + "转换成double类型失败，请检查数据来源");
        }
        return 0;
    }

    /**
     * 描述：字符转为一个元素的Object数组
     *
     * @param str
     * @return
     */
    public static Object[] strToArry(String str) {
        if (str == null) {
            return null;
        } else {
            return new Object[] { str };
        }
    }

    /**
     * 对于一个字符串数组，把字符串数组中的每一个字串转换为整数。
     * 返回一个转换后的整型数组，对于每一个字串若转换失败，则对 应的整型值就为0
     *
     * @param strArray
     * @return
     */
    public static int[] strArrayToIntArray(String[] strArray) {
        int[] intArray = new int[strArray.length];
        for (int i = 0; i < strArray.length; i++) {
            intArray[i] = strToInt(strArray[i]);
        }
        return intArray;
    }

    /**
     * 描述：数组转换为字符串
     *
     * @param arg0
     * @return
     */
    public static String arrToString(Object[] arg0) {
        if (arg0 == null) {
            return "";
        }
        return arrToString(arg0, ",");
    }

    /**
     * 描述：数据转换为字符串
     *
     * @param arg0 数组
     * @param arg1 取数组个数
     * @return
     */
    public static String arrToString(Object[] arg0, int arg1) {
        if (arg0 == null) {
            return "";
        }
        return arrToString(arg0, ",", arg1);
    }

    /**
     * 描述：数据转换为字符串
     *
     * @param arg0 数组
     * @param arg1 间隔符号
     * @return
     */
    public static String arrToString(Object[] arg0, String arg1) {
        return arrToString(arg0, arg1, 0);
    }

    /**
     * 描述：数据转换为字符串
     *
     * @param arg0 数组
     * @param arg1 间隔符号
     * @param arg2 取数组个数
     * @return
     */
    public static String arrToString(Object[] arg0, String arg1, int arg2) {
        if (arg0 == null || arg0.length == 0) {
            return "";
        } else {
            StringBuffer sb = new StringBuffer();
            int length = arg0.length;
            if (arg2 != 0) {
                length = arg2;
            }
            for (int i = 0; i < length; i++) {
                if (arg1 == null) {
                    arg1 = "";
                }
                sb.append(arg0[i]).append(arg1);
            }
            sb.delete(sb.lastIndexOf(arg1), sb.length());
            return sb.toString();
        }
    }

    /**
     * 描述：List转换为字符串
     *
     * @param list List数据
     * @return
     */
    public static String listToString(List<?> list) {
        return listToString(list, ",");
    }

    /**
     * 描述：List转换为字符串
     *
     * @param list List数据
     * @param separation 间隔符
     * @return
     */
    public static String listToString(List<?> list, String separation) {
        return arrToString(listToStringArray(list), separation);
    }

    /**
     * 描述：字串数据元素包装
     *
     * @param sArr 字串数据
     * @param pre 前缀
     * @param aft 后缀
     * @return
     */
    public static String[] strArrDoPack(String[] sArr, String pre, String aft) {
        return strArrDoPack(sArr, pre, aft, 1, 0);
    }

    /**
     * 描述：字串数据元素包装
     *
     * @param sArr 字串数据
     * @param pre 前缀
     * @param aft 后缀
     * @param num 生成个数
     * @return
     */
    public static String[] strArrDoPack(String[] sArr, String pre, String aft, int num) {
        return strArrDoPack(sArr, pre, aft, num, 0);
    }

    /**
     * 描述：字串数据元素包装
     *
     * @param sArr 字串数据
     * @param pre 前缀
     * @param aft 后缀
     * @param num 生成个数
     * @param step 数字值1：加，-1：减，0：不变
     * @return
     */
    public static String[] strArrDoPack(String[] sArr, String pre, String aft, int num, int step) {
        String[] arr = null;
        if (sArr != null) {
            boolean isAdd = false;
            if (step > 0) {
                isAdd = true;
            }

            if (num < 0) {
                num = 1;
            }

            arr = new String[sArr.length * num];
            int icount = 0;
            for (int i = 0; i < num; i++) {
                for (int j = 0; j < sArr.length; j++) {
                    if (ValidateUtil.isNotEmpty(pre)) {
                        arr[icount] = pre + sArr[j];
                    }
                    if (ValidateUtil.isNotEmpty(aft)) {
                        arr[icount] += aft;
                    }
                    icount++;
                }

                boolean b = false;
                if (step != 0) {
                    pre = stepNumInStr(pre, isAdd);
                    b = true;
                }
                if (!b) {
                    if (step != 0) {
                        aft = stepNumInStr(aft, isAdd);
                    }
                }
            }

        }
        return arr;
    }

    /**
     * 描述：生成字符串
     *
     * @param arg0 字符串元素
     * @param arg1 生成个数
     * @return
     */
    public static String createStr(String arg0, int arg1) {
        if (arg0 == null) {
            return "";
        }
        return createStr(arg0, arg1, ",");
    }

    /**
     * 描述：生成字符串
     *
     * @param arg0 字符串元素
     * @param arg1 生成个数
     * @param arg2 间隔符号
     * @return
     */
    public static String createStr(String arg0, int arg1, String arg2) {
        if (arg0 == null) {
            return "";
        } else {
            StringBuffer sb = new StringBuffer();
            for (int i = 0; i < arg1; i++) {
                if (arg2 == null){
                    arg2 = "";
                }
                sb.append(arg0).append(arg2);
            }
            if (sb.length() > 0) {
                sb.delete(sb.lastIndexOf(arg2), sb.length());
            }

            return sb.toString();
        }
    }

    /**
     * 描述：生成字符串数据
     *
     * @param arg0 字符串元素
     * @param arg1 生成个数
     * @return
     */
    public static String[] createStrArr(String arg0, int arg1) {
        if (arg0 == null) {
            return null;
        } else {
            String[] arr = new String[arg1];
            for (int i = 0; i < arg1; i++) {
                arr[i] = arg0;
            }

            return arr;
        }
    }

    /**
     * 描述：只保留字符串的英文字母和“_”号
     *
     * @param str
     * @return
     */
    public static String replaceAllSign(String str) {
        if (str != null && str.length() > 0) {
            str = str.replaceAll("[^a-zA-Z_]", "");
        }
        return str;
    }

    /**
     * 描述：字串中的数字值加1
     *
     * @param str 字串
     * @param isAdd 数字值true：加，false：减
     * @return
     */
    public static String stepNumInStr(String str, boolean isAdd) {
        String sNum = str.replaceAll("[^0-9]", ",").trim();
        if (sNum == null || sNum.length() == 0) {
            return str;
        }
        String[] sNumArr = sNum.split(",");

        for (int i = 0; i < sNumArr.length; i++) {
            if (sNumArr[i] != null && sNumArr[i].length() > 0) {
                int itemp = Integer.parseInt(sNumArr[i]);
                if (isAdd) {
                    itemp += 1;
                } else {
                    itemp -= 1;
                }
                str = str.replaceFirst(sNumArr[i], String.valueOf(itemp));
                break;
            }
        }

        return str;
    }

    /**
     * 描述：list 转换为 String[]
     *
     * @param list
     * @return
     */
    public static String[] listToStringArray(List<?> list) {
        if (list == null || list.size() == 0) {
            return null;
        }
        return (String[]) list.toArray(new String[list.size()]);
    }
}
